﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace FileRenameToolsV1
{
    public partial class FFRTMain : Form
    {
        public FFRTMain()
        {
            InitializeComponent();
            listViewFiles.Items.Clear();
            listViewDestList.Items.Clear();
        }

        // 跟踪被拖动的项
        private ListViewItem draggedItem = null;
        // 拖动时显示的高亮索引
        private int highlightIndex = -1;

        private void listViewFiles_MouseDown(object sender, MouseEventArgs e)
        {
            // 获取鼠标点击位置的项
            ListViewItem item = listViewFiles.GetItemAt(e.X, e.Y);
            if (item != null)
            {
                draggedItem = item;
            }
        }

        private void listViewFiles_MouseMove(object sender, MouseEventArgs e)
        {
            // 当鼠标移动且有选中项时，开始拖动操作
            if (e.Button == MouseButtons.Left && draggedItem != null)
            {
                // 开始拖动
                listViewFiles.DoDragDrop(draggedItem, DragDropEffects.Move);
                draggedItem = null; // 重置拖动项
                highlightIndex = -1; // 重置高亮索引
                listViewFiles.Invalidate(); // 重绘以清除高亮
            }
        }

        private void listViewFiles_DrawItem(object sender, DrawListViewItemEventArgs e)
        {
            // 绘制默认项
            e.DrawDefault = true;

            // 如果是拖动时的高亮位置，绘制高亮效果
            if (e.Item.Index == highlightIndex)
            {
                // 创建高亮背景
                using (var brush = new System.Drawing.SolidBrush(System.Drawing.Color.LightBlue))
                {
                    e.Graphics.FillRectangle(brush, e.Bounds);
                }
                // 绘制文本
                e.Graphics.DrawString(e.Item.Text, e.Item.Font,
                    System.Drawing.Brushes.Black, e.Bounds.Location);
            }
            else
            {
                e.DrawDefault = true;
            }
        }

        private void listViewFiles_DragOver(object sender, DragEventArgs e)
        {
            // 允许拖放操作
            e.Effect = DragDropEffects.Move;

            // 获取当前鼠标位置对应的项索引
            Point point = listViewFiles.PointToClient(new Point(e.X, e.Y));
            ListViewItem hoverItem = listViewFiles.GetItemAt(point.X, point.Y);

            // 更新高亮索引并刷新
            if (hoverItem != null && draggedItem != null && hoverItem.Index != draggedItem.Index)
            {
                highlightIndex = hoverItem.Index;
                listViewFiles.Invalidate();
            }
        }

        private void listViewFiles_DragDrop(object sender, DragEventArgs e)
        {
            // 获取拖放位置
            Point point = listViewFiles.PointToClient(new Point(e.X, e.Y));
            ListViewItem targetItem = listViewFiles.GetItemAt(point.X, point.Y);

            if (draggedItem == null)
            {
                // 获取拖放的文件路径
                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);

                if (files != null && files.Length > 0)
                {
                    // 只处理第一个文件
                    string filePath = files[0];

                    int targetIndex = listViewFiles.Items.Count;
                    if (targetItem != null)
                        targetIndex = targetItem.Index;
                    foreach (string file in files)
                    {
                        string sNameEx = Path.GetFileName(file);
                        string sName = Path.GetFileNameWithoutExtension(file);
                        string sExtN = sNameEx.Replace(sName, string.Empty);
                        //string sDir=Path.GetDirectoryName(file);
                        if (!checkFileInList(file))
                        {
                            ListViewItem tNewItem = new ListViewItem();
                            tNewItem.Text = sName;
                            tNewItem.SubItems.Add(sExtN);
                            tNewItem.SubItems.Add(file);
                            listViewFiles.Items.Insert(targetIndex, tNewItem);
                            targetIndex++;
                        }
                    }
                }
            }
            else
            {
                if (targetItem != null)
                {
                    listViewFiles.ListViewItemSorter = null;
                    if (targetItem != draggedItem)
                    {
                        // 保存源索引和目标索引
                        int sourceIndex = draggedItem.Index;
                        int targetIndex = targetItem.Index;

                        // 创建项的副本（因为直接移动会导致索引变化）
                        ListViewItem itemCopy = (ListViewItem)draggedItem.Clone();

                        // 从原位置移除
                        listViewFiles.Items.Remove(draggedItem);

                        // 插入到新位置
                        // 如果目标索引大于源索引，需要减1（因为源项已被移除）
                        if (targetIndex > sourceIndex)
                        {
                            targetIndex--;
                        }
                        listViewFiles.Items.Insert(targetIndex, itemCopy);

                        // 选中新插入的项
                        listViewFiles.Items[targetIndex].Selected = true;
                    }
                }
                else
                {
                    // 创建项的副本（因为直接移动会导致索引变化）
                    ListViewItem itemCopy = (ListViewItem)draggedItem.Clone();

                    // 从原位置移除
                    listViewFiles.Items.Remove(draggedItem);
                    listViewFiles.Items.Add(itemCopy);

                    // 选中新插入的项
                    itemCopy.Selected = true;
                }
            }
            // 清除高亮
            highlightIndex = -1;
            listViewFiles.Invalidate();
            buttonSave.Enabled = getFileNameList();
        }

        private void listViewFiles_DragEnter(object sender, DragEventArgs e)
        {
            // 检查拖放的数据是否包含文件
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                // 设置拖放效果为复制
                e.Effect = DragDropEffects.Copy;
            }
            else
            {
                // 不接受其他类型的拖放数据
                e.Effect = DragDropEffects.None;
            }
        }

        private bool checkFileInList(string sFileName)
        {
            if (listViewFiles.Items.Count > 0)
                foreach (ListViewItem item in listViewFiles.Items)
                    if (item.SubItems[1].Text == sFileName)
                        return true;
            return false;
        }

        // 当前排序列索引（默认为第一列）
        private int sortColumn = 0;
        // 当前排序方向（true为升序，false为降序）
        private bool isAscending = true;
        // 排序比较器
        private ListViewItemComparer lvwComparer = new ListViewItemComparer();

        private void listViewFiles_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            // 只处理第一列的点击（索引为0）
            if (e.Column != 0) return;

            listViewFiles.ListViewItemSorter = lvwComparer;
            // 如果点击的是当前排序列，切换排序方向
            if (e.Column == sortColumn)
            {
                isAscending = !isAscending;
            }
            else
            {
                // 点击新列（这里固定为第一列，所以其实不会触发此逻辑）
                sortColumn = e.Column;
                isAscending = true; // 默认升序
            }

            // 设置比较器的排序参数
            lvwComparer.SortColumn = sortColumn;
            lvwComparer.Order = isAscending ? SortOrder.Ascending : SortOrder.Descending;

            // 执行排序
            listViewFiles.Sort();
        }

        /// <summary>
        /// 提取字符串中最内侧且第一个出现的成对小括号内容
        /// </summary>
        /// <param name="input">输入字符串</param>
        /// <returns>最内侧第一个括号内容，无匹配则返回空字符串</returns>
        private string ExtractFirstInnermostContent(string input)
        {
            // 正则表达式：匹配"内部无其他括号的括号对"（即最内侧括号）
            // \(: 匹配左括号（转义处理）
            // ([^()]*): 捕获组，匹配"除小括号外的任意字符"（确保内部无嵌套）
            // \): 匹配右括号（转义处理）
            Regex regex = new Regex(@"\(([^()]*)\)");

            // 获取所有最内侧括号的匹配结果
            MatchCollection matches = regex.Matches(input);

            // 若有匹配结果，返回第一个匹配的括号内内容；否则返回空
            return matches.Count > 0 ? matches[0].Groups[1].Value : string.Empty;
        }

        private void numericUpDownStar_ValueChanged(object sender, EventArgs e)
        {
            buttonSave.Enabled = getFileNameList();
        }

        private void textBoxRenameMask_Leave(object sender, EventArgs e)
        {
           buttonSave.Enabled= getFileNameList();
        }

        private bool getFileNameList()
        {
            string sRNMask = textBoxRenameMask.Text;
            string sFlower = ExtractFirstInnermostContent(sRNMask);
            if ((!string.IsNullOrEmpty(sRNMask)) && (!string.IsNullOrEmpty(sFlower))
                && (listViewFiles.Items.Count > 0))
            {
                listViewDestList.Items.Clear();
                int iFlow = (int)numericUpDownStar.Value;
                foreach (ListViewItem item in listViewFiles.Items)
                {
                    string sTmp1 = iFlow.ToString();
                    string sTmp2 = "";
                    if (sTmp1.Length < sFlower.Length)
                    {
                        sTmp2 = "00000000000" + iFlow.ToString();

                        if (sTmp2.Length > sFlower.Length)
                            sTmp2 = sTmp2.Substring(sTmp2.Length - sFlower.Length, sFlower.Length);
                    }
                    if (!string.IsNullOrEmpty(sTmp2))
                    {
                        string sDestFN = sRNMask.Replace($"({sFlower})", sTmp2) + item.SubItems[1].Text;
                        string sDestFNDir = textBoxDestDir.Text + "\\" + sDestFN;
                        ListViewItem tNewItem = new ListViewItem();
                        tNewItem.Text = sDestFN;
                        tNewItem.SubItems.Add(sDestFNDir);
                        listViewDestList.Items.Add(tNewItem);
                    }
                    iFlow++;
                }
                return true;
            }
            return false;
        }

        private void textBoxDestDir_DoubleClick(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(textBoxDestDir.Text))
            {
                openFileDialogDir.InitialDirectory= textBoxDestDir.Text;
            }
            textBoxDestDir.Text = "";
            if (openFileDialogDir.ShowDialog() == DialogResult.OK)
                textBoxDestDir.Text = Path.GetDirectoryName( openFileDialogDir.FileName);
        }
    }

    #region 自定义排序比较器
    // 实现IComparer接口的比较器类
    class ListViewItemComparer : IComparer
    {
        // 排序列索引
        public int SortColumn { get; set; }
        // 排序方向
        public SortOrder Order { get; set; }

        public ListViewItemComparer()
        {
            // 默认排序列和方向
            SortColumn = 0;
            Order = SortOrder.Ascending;
        }

        // 核心比较逻辑
        public int Compare(object x, object y)
        {
            ListViewItem itemX = x as ListViewItem;
            ListViewItem itemY = y as ListViewItem;

            // 比较第一列的文本（SubItems[0]对应第一列）
            int compareResult = string.Compare(
                itemX.SubItems[SortColumn].Text,
                itemY.SubItems[SortColumn].Text
            );

            // 根据排序方向返回结果
            if (Order == SortOrder.Ascending)
            {
                return compareResult;
            }
            else
            {
                return -compareResult; // 降序则取反
            }
        }
    }
    #endregion

}